/**
 * @ParseUtils.as
 * 
 * @author sodaChen mail:asframe#163.com
 * @version 1.0
 * <br>Copyright (C), 2012 ASFrame.com
 * <br>This program is protected by copyright laws.
 * <br>Program Name:ASFrame
 * <br>Date:2012-1-14
 */
package com.asframe.utils
{
	import flash.utils.ByteArray;

	/**
	 *
	 * @author sodaChen
	 * Date:2012-1-14
	 */
	public class ParseUtils
	{
		//是否为Email地址;  
		public static function isEmail(char:String):Boolean
		{  
			if(char == null)
			{  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}/;  
			
			return pattern.exec(char) != null;
		}  
		
		//是否是数值字符串;  
		public static function isNumber(char:String):Boolean
		{  
			if(char == null)
			{  
				return false;  
			}  
			return !isNaN(Number(char));  
		}  
		
		//是否为Double型数据;  
		public static function isDouble(char:String):Boolean
		{  
			char = trim(char);  
			var pattern:RegExp = /^[-\+]?\d+(\.\d+)?$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) 
			{  
				return false;  
			}  
			return true;  
		}  
		//Integer;  
		public static function isInteger(char:String):Boolean
		{  
			if(char == null)
			{  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /^[-\+]?\d+$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) 
			{  
				return false;  
			}  
			return true;  
		}  
		//English;  
		public static function isEnglish(char:String):Boolean{  
			if(char == null){  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /^[A-Za-z]+$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		//中文;  
		public static function isChinese(char:String):Boolean{  
			if(char == null){  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /^[\u0391-\uFFE5]+$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		//双字节  
		public static function isDoubleChar(char:String):Boolean{  
			if(char == null){  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /^[^\x00-\xff]+$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		
		//含有中文字符  
		public static function hasChineseChar(char:String):Boolean{  
			if(char == null){  
				return false;  
			}  
			char = trim(char);  
			var pattern:RegExp = /[^\x00-\xff]/;  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		//注册字符;  
		public static function hasAccountChar(char:String,len:uint=15):Boolean{  
			if(char == null){  
				return false;  
			}  
			if(len < 10){  
				len = 15;  
			}  
			char = trim(char);  
			var pattern:RegExp = new RegExp("^[a-zA-Z0-9][a-zA-Z0-9_-]{0,"+len+"}$", "");  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		//URL地址;  
		public static function isURL(char:String):Boolean{  
			if(char == null){  
				return false;  
			}  
			char = trim(char).toLowerCase();  
			var pattern:RegExp = /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/;  
			var result:Object = pattern.exec(char);  
			if(result == null) {  
				return false;  
			}  
			return true;  
		}  
		
		// 是否为空白;        
		public static function isWhitespace(char:String):Boolean{  
			switch (char){  
				case " ":  
				case "\t":  
				case "\r":  
				case "\n":  
				case "\f":  
					return true;      
				default:  
					return false;  
			}  
		}  
		
		//去左右空格;  
		public static function trim(char:String):String{  
			if(char == null){  
				return null;  
			}  
			return rtrim(ltrim(char));  
		}  
		
		//去左空格;  
		public static function ltrim(char:String):String{  
			if(char == null){  
				return null;  
			}  
			var pattern:RegExp = /^\s*/;  
			return char.replace(pattern,"");  
		}  
		
		//去右空格;  
		public static function rtrim(char:String):String{  
			if(char == null){  
				return null;  
			}  
			var pattern:RegExp = /\s*$/;  
			return char.replace(pattern,"");  
		}  
		
		//是否为前缀字符串;  
		public static function beginsWith(char:String, prefix:String):Boolean{            
			return (prefix == char.substring(0, prefix.length));  
		}  
		
		//是否为后缀字符串;  
		public static function endsWith(char:String, suffix:String):Boolean{  
			return (suffix == char.substring(char.length - suffix.length));  
		}  
		
		//去除指定字符串;  
		public static function remove(char:String,remove:String):String{  
			return replace(char,remove,"");  
		}  
		
		//字符串替换;  
		public static function replace(char:String, replace:String, replaceWith:String):String{          
			return char.split(replace).join(replaceWith);  
		}  
		
		//utf16转utf8编码;  
		public static function utf16to8(char:String):String{  
			var out:Array = new Array();  
			var len:uint = char.length;  
			for(var i:uint=0;i<len;i++){  
				var c:int = char.charCodeAt(i);  
				if(c >= 0x0001 && c <= 0x007F){  
					out[i] = char.charAt(i);  
				} else if (c > 0x07FF) {  
					out[i] = String.fromCharCode(0xE0 | ((c >> 12) & 0x0F),  
						0x80 | ((c >>  6) & 0x3F),  
						0x80 | ((c >>  0) & 0x3F));  
				} else {  
					out[i] = String.fromCharCode(0xC0 | ((c >>  6) & 0x1F),  
						0x80 | ((c >>  0) & 0x3F));  
				}  
			}  
			return out.join('');  
		}  
		
		//utf8转utf16编码;  
		public static function utf8to16(char:String):String{  
			var out:Array = new Array();  
			var len:uint = char.length;  
			var i:uint = 0;  
			var char2:int,char3:int;  
			while(i<len){  
				var c:int = char.charCodeAt(i++);  
				switch(c >> 4){  
					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:  
						// 0xxxxxxx  
						out[out.length] = char.charAt(i-1);  
						break;  
					case 12: case 13:  
						// 110x xxxx   10xx xxxx  
						char2 = char.charCodeAt(i++);  
						out[out.length] = String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));  
						break;  
					case 14:  
						// 1110 xxxx  10xx xxxx  10xx xxxx  
						char2 = char.charCodeAt(i++);  
						char3 = char.charCodeAt(i++);  
						out[out.length] = String.fromCharCode(((c & 0x0F) << 12) |  
							((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));  
						break;  
				}  
			}  
			return out.join('');  
		}  
		
		//转换字符编码;  
		public static function encodeCharset(char:String,charset:String):String{  
			var bytes:ByteArray = new ByteArray();  
			bytes.writeUTFBytes(char);  
			bytes.position = 0;  
			return bytes.readMultiByte(bytes.length,charset);  
		}  
		
		//添加新字符到指定位置;        
		public static function addAt(char:String, value:String, position:int):String {  
			if (position > char.length) {  
				position = char.length;  
			}  
			var firstPart:String = char.substring(0, position);  
			var secondPart:String = char.substring(position, char.length);  
			return (firstPart + value + secondPart);  
		}  
		
		//替换指定位置字符;  
		public static function replaceAt(char:String, value:String, beginIndex:int, endIndex:int):String {  
			beginIndex = Math.max(beginIndex, 0);            
			endIndex = Math.min(endIndex, char.length);  
			var firstPart:String = char.substr(0, beginIndex);  
			var secondPart:String = char.substr(endIndex, char.length);  
			return (firstPart + value + secondPart);  
		}  
		
		//        //删除指定位置字符;  
		//        public static function removeAt(char:String, beginIndex:int, endIndex:int):String {  
		//            return StringUtil.replaceAt(char, "", beginIndex, endIndex);  
		//        }  
		
		//修复双换行符;  
		public static function fixNewlines(char:String):String 
		{  
			return char.replace(/\r\n/gm, "\n");  
		}  
		/**
		 * 字符串的字节长度 
		 * @param str:判断的字符串
		 * @param code:字符串的编码
		 * @return 
		 * 
		 */		
		public static function strByteLength(str:String,code:String = "UTF-8"):int
		{
			var bytes:ByteArray = new ByteArray();
			bytes.writeMultiByte(str,code);
			return bytes.length;
		}
	}
}
